home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / agl103p.lha / src / agl / RCS / matrix.c,v < prev    next >
Encoding:
Text File  |  1994-12-09  |  33.9 KB  |  1,784 lines
  1. head    1.2;
  2. branch    1.2.1.99;
  3. access;
  4. symbols;
  5. locks; strict;
  6. comment    @ * @;
  7.  
  8.  
  9. 1.2
  10. date    93.03.15.23.25.36;    author jason;    state Exp;
  11. branches
  12.     1.2.1.1;
  13. next    ;
  14.  
  15. 1.2.1.1
  16. date    94.03.29.05.41.32;    author jason;    state Exp;
  17. branches;
  18. next    1.2.1.2;
  19.  
  20. 1.2.1.2
  21. date    94.04.02.03.33.11;    author jason;    state Exp;
  22. branches;
  23. next    1.2.1.3;
  24.  
  25. 1.2.1.3
  26. date    94.04.06.02.39.10;    author jason;    state Exp;
  27. branches;
  28. next    1.2.1.4;
  29.  
  30. 1.2.1.4
  31. date    94.09.13.03.48.33;    author jason;    state Exp;
  32. branches;
  33. next    1.2.1.5;
  34.  
  35. 1.2.1.5
  36. date    94.11.18.07.49.22;    author jason;    state Exp;
  37. branches;
  38. next    1.2.1.6;
  39.  
  40. 1.2.1.6
  41. date    94.12.09.05.29.56;    author jason;    state Exp;
  42. branches;
  43. next    ;
  44.  
  45.  
  46. desc
  47. @transformations
  48. @
  49.  
  50.  
  51. 1.2
  52. log
  53. @Initial RCS Version
  54. @
  55. text
  56. @#include"agl.h"
  57.  
  58. /*
  59.  *  near and far cutting planes are included, but have no effect
  60.  */
  61.  
  62. #define    FAST_PROJECTION    TRUE
  63. #define    FAST_PUSH        TRUE
  64. #define SINE_TABLE        TRUE
  65.  
  66.  
  67. /* ProjectionType enumeration */
  68. #define ORTHO        0
  69. #define PERSPECTIVE    1
  70.  
  71.  
  72. short MatrixLevel[MAX_WINDOWS],ProjectionType[MAX_WINDOWS];
  73. float Projection[MAX_WINDOWS][4][4];
  74. float Rotate[MAX_WINDOWS][MATRIXSTACKDEPTH][3][3];
  75. float Translation[MAX_WINDOWS][MATRIXSTACKDEPTH][3];
  76. float Sine[3600];
  77.  
  78.  
  79. /******************************************************************************
  80. void    init_matrices(void)
  81.  
  82. ******************************************************************************/
  83. /*PROTOTYPE*/
  84. void init_matrices(void)
  85.     {
  86.     long wid;
  87.     short x,y;
  88.  
  89.     /* create sin table */
  90.     for(x=0;x<3600;x++)
  91.         Sine[x]=sin(x/10.0*DEG);
  92.  
  93.     for(wid=0;wid<MAX_WINDOWS;wid++)
  94.         {
  95.         MatrixLevel[wid]=0;
  96.  
  97.         for(x=0;x<3;x++)
  98.             {
  99.             Translation[wid][0][x]=0.0;
  100.  
  101.             for(y=0;y<3;y++)
  102.                 if(x==y)
  103.                     Rotate[wid][0][y][x]=1.0;
  104.                 else
  105.                     Rotate[wid][0][y][x]=0.0;
  106.             }
  107.         }
  108.     }
  109.  
  110.  
  111. /******************************************************************************
  112. void pushmatrix(void)
  113.  
  114. ******************************************************************************/
  115. /*PROTOTYPE*/
  116. void pushmatrix(void)
  117.     {
  118.     short x,y,m;
  119.  
  120.     if(MatrixLevel[CurrentWid]==MATRIXSTACKDEPTH-1)
  121.         GL_error("Too many matrices pushed");
  122.     else
  123.         {
  124.         m= ++MatrixLevel[CurrentWid];
  125.  
  126. #if FAST_PUSH
  127.  
  128.         memcpy(&Translation[CurrentWid][m][0],&Translation[CurrentWid][m-1][0],3*sizeof(float));
  129.         memcpy(&Rotate[CurrentWid][m][0][0],&Rotate[CurrentWid][m-1][0][0],9*sizeof(float));
  130.  
  131. #else
  132.         for(y=0;y<3;y++)
  133.             {
  134.             Translation[CurrentWid][m][y]=Translation[CurrentWid][m-1][y];
  135.             for(x=0;x<3;x++)
  136.                 Rotate[CurrentWid][m][y][x]=Rotate[CurrentWid][m-1][y][x];
  137.             }
  138. #endif
  139.  
  140.         }
  141.     }
  142.  
  143.  
  144. /******************************************************************************
  145. void    popmatrix(void)
  146.  
  147. ******************************************************************************/
  148. /*PROTOTYPE*/
  149. void popmatrix(void)
  150.     {
  151.     if(MatrixLevel[CurrentWid]==0)
  152.         GL_error("Too many matrices popped");
  153.     else
  154.         MatrixLevel[CurrentWid]--;
  155.  
  156.     if(MatrixLevel[CurrentWid]==0)    /* gotta have some way to go back */
  157.         Dimensions[CurrentWid]=2;
  158.     }
  159.  
  160.  
  161. /******************************************************************************
  162. void    project_vertex(float in[3],float out[3])
  163.  
  164.     applies perspective on transformed vertex
  165. ******************************************************************************/
  166. /*PROTOTYPE*/
  167. void project_vertex(float in[3],float out[3])
  168.     {
  169. #if !FAST_PROJECTION
  170.  
  171.     short y,m;
  172.     float sum,before[4],mid[4];
  173.  
  174.     /* complete: general purpose, any transform matrix */
  175.     for(y=0;y<3;y++)
  176.         before[y]=in[y];
  177.     before[3]=1.0;
  178.  
  179.     for(y=0;y<4;y++)
  180.         {
  181.         sum=0.0;
  182.         for(m=0;m<4;m++)
  183.             sum+=Projection[CurrentWid][y][m]*before[m];
  184.         mid[y]=sum;
  185.         }
  186.  
  187.     /* divide out range factor */
  188.     for(y=0;y<3;y++)
  189.         out[y]=Projection[CurrentWid][3][2]*mid[y]/mid[3];
  190.  
  191. #else
  192.  
  193.     /* fast: compute only x and y for specific transform */
  194.     if(ProjectionType[CurrentWid]==PERSPECTIVE)
  195.         {
  196.         out[0]=Projection[CurrentWid][0][0]*in[0]/in[2];
  197.         out[1]=Projection[CurrentWid][1][1]*in[1]/in[2];
  198.         }
  199.     else
  200.         {
  201.         out[0]=Projection[CurrentWid][0][0]*in[0]+Projection[CurrentWid][3][0];
  202.         out[1]=Projection[CurrentWid][1][1]*in[1]+Projection[CurrentWid][3][1];
  203.         }
  204.  
  205. #endif
  206.     }
  207.  
  208.  
  209. /******************************************************************************
  210. void    perspective(long angle,float aspect,float near,float far)
  211.  
  212.     angle in integer number of tenths of degrees
  213.  
  214.     sets Projection[][]
  215. ******************************************************************************/
  216. /*PROTOTYPE*/
  217. void perspective(long angle,float aspect,float near,float far)
  218.     {
  219.     float fovy,cot;
  220.  
  221.     OneToOne[CurrentWid]=FALSE;
  222.     Dimensions[CurrentWid]=3;
  223.     ProjectionType[CurrentWid]=PERSPECTIVE;
  224.  
  225.     fovy=angle*DEG/10.0;
  226.     cot=1.0/tan(fovy/2.0);
  227.  
  228. #if !FAST_PROJECTION
  229.     memset(&Projection[CurrentWid][0][0],0,16*4);
  230. #endif
  231.  
  232.     Projection[CurrentWid][0][0]=cot/aspect;
  233.     Projection[CurrentWid][1][1]=cot;
  234.     Projection[CurrentWid][2][2]=     -(far+near)/(far-near);
  235.     Projection[CurrentWid][2][3]= -1.0;
  236.     Projection[CurrentWid][3][2]= -(2.0*far*near)/(far-near);
  237.  
  238. /*
  239.     printf("angle=%d fovy=%.2f cot=%.2f Proj=%.2f %.2f\n",angle,fovy,cot,
  240.                                                     Projection[CurrentWid][0][0],Projection[CurrentWid][1][1]);
  241. */
  242.     }
  243.  
  244.  
  245. /******************************************************************************
  246. void    ortho(float left,float right,float bottom,float top,
  247.                                                         float near,float far)
  248.  
  249. ******************************************************************************/
  250. /*PROTOTYPE*/
  251. void ortho(float left,float right,float bottom,float top,float near,float far)
  252.     {
  253.     ortho2(left,right,bottom,top);
  254.  
  255.     Projection[CurrentWid][2][2]= -2.0/(far-near);
  256.     Projection[CurrentWid][3][2]= -(far+near)/(far-near);
  257.     }
  258.  
  259.  
  260. /******************************************************************************
  261. void    ortho2(float left,float right,float bottom,float top)
  262.  
  263. ******************************************************************************/
  264. /*PROTOTYPE*/
  265. void ortho2(float left,float right,float bottom,float top)
  266.     {
  267. #if !FAST_PROJECTION
  268.     memset(&Projection[CurrentWid][0][0],0,16*4);
  269. #endif
  270.  
  271.     Projection[CurrentWid][0][0]=2.0/(right-left);
  272.     Projection[CurrentWid][1][1]=2.0/(top-bottom);
  273.     Projection[CurrentWid][2][2]= -1.0;
  274.     Projection[CurrentWid][3][0]= -(right+left)/(right-left);
  275.     Projection[CurrentWid][3][1]= -(top+bottom)/(top-bottom);
  276.     Projection[CurrentWid][3][3]=1.0;
  277.  
  278.     if( left==(-0.5) && right==(CurrentWidth-0.5) && bottom==(-0.5) && top==(CurrentHeight-0.5) )
  279.         OneToOne[CurrentWid]=TRUE;
  280.     else
  281.         OneToOne[CurrentWid]=FALSE;
  282.  
  283.     ProjectionType[CurrentWid]=ORTHO;
  284.     }
  285.  
  286.  
  287. /******************************************************************************
  288. void    v2i(long lvert[2])
  289.  
  290. ******************************************************************************/
  291. /*PROTOTYPE*/
  292. void v2i(long lvert[2])
  293.     {
  294.     float fvert[3];
  295.     short svert[2];
  296.  
  297.     if(OneToOne[CurrentWid])    /* bypass transforms if no effect */
  298.         {
  299.         svert[0]=lvert[0];
  300.         svert[1]=lvert[1];
  301.         render_vertex(svert);
  302.         }
  303.     else
  304.         {
  305.         fvert[0]=lvert[0];
  306.         fvert[1]=lvert[1];
  307.         fvert[2]=0.0;
  308.  
  309.         v3f(fvert);
  310.         }
  311.     }
  312.  
  313.  
  314. /******************************************************************************
  315. void    v3i(long lvert[3])
  316.  
  317. ******************************************************************************/
  318. /*PROTOTYPE*/
  319. void v3i(long lvert[3])
  320.     {
  321.     float fvert[3];
  322.  
  323.     fvert[0]=lvert[0];
  324.     fvert[1]=lvert[1];
  325.     fvert[2]=lvert[2];
  326.  
  327.     v3f(fvert);
  328.     }
  329.  
  330.  
  331. /******************************************************************************
  332. void    v2s(short svert[2])
  333.  
  334. ******************************************************************************/
  335. /*PROTOTYPE*/
  336. void v2s(short svert[2])
  337.     {
  338.     float fvert[3];
  339.  
  340.     if(OneToOne[CurrentWid])    /* bypass transforms if no effect */
  341.         render_vertex(svert);
  342.     else
  343.         {
  344.         fvert[0]=svert[0];
  345.         fvert[1]=svert[1];
  346.         fvert[2]=0.0;
  347.  
  348.         v3f(fvert);
  349.         }
  350.     }
  351.  
  352.  
  353. /******************************************************************************
  354. void    v3s(short svert[3])
  355.  
  356. ******************************************************************************/
  357. /*PROTOTYPE*/
  358. void v3s(short svert[3])
  359.     {
  360.     float fvert[3];
  361.  
  362.     fvert[0]=svert[0];
  363.     fvert[1]=svert[1];
  364.     fvert[2]=svert[2];
  365.  
  366.     v3f(fvert);
  367.     }
  368.  
  369.  
  370. /******************************************************************************
  371. void    v2f(float fvert2[2])
  372.  
  373. ******************************************************************************/
  374. /*PROTOTYPE*/
  375. void v2f(float fvert2[2])
  376.     {
  377.     float fvert[3];
  378.     short svert[2];
  379.  
  380.     if(OneToOne[CurrentWid])    /* bypass transforms if no effect */
  381.         {
  382.         svert[0]=fvert2[0];
  383.         svert[1]=fvert2[1];
  384.         render_vertex(svert);
  385.         }
  386.     else
  387.         {
  388.         fvert[0]=fvert2[0];
  389.         fvert[1]=fvert2[1];
  390.         fvert[2]=0.0;
  391.  
  392.         v3f(fvert);
  393.         }
  394.     }
  395.  
  396.  
  397. /******************************************************************************
  398. void    v3f(float vert[3])
  399.  
  400. ******************************************************************************/
  401. /*PROTOTYPE*/
  402. void v3f(float vert[3])
  403.     {
  404.     float rvert[3],pvert[3];
  405.     short svert[2];
  406.  
  407.     rotate_translate_position(vert,rvert);
  408.     project_vertex(rvert,pvert);
  409.  
  410.     svert[0]=CurrentWidth*(pvert[0]+1.0)/2.0+0.5;
  411.     svert[1]=CurrentHeight*(pvert[1]+1.0)/2.0+0.5;
  412.     render_vertex(svert);
  413.  
  414. /*
  415. if(CurrentWid==2)
  416. {
  417. printf("%5.3f %5.3f %5.3f -> %5.3f %5.3f %5.3f -> ",vert[0],vert[1],vert[2],rvert[0],rvert[1],rvert[2]);
  418. printf("%5.3f %5.3f -> %4d %4d\n",pvert[0],pvert[1],svert[0],svert[1]);
  419. }
  420. */
  421.     }
  422.  
  423.  
  424. /******************************************************************************
  425. void    rotate_translate_position(float vert[3],float rvert[3])
  426.  
  427.     calls rotate_position()
  428.     adds Translation[]
  429. ******************************************************************************/
  430. /*PROTOTYPE*/
  431. void rotate_translate_position(float vert[3],float rvert[3])
  432.     {
  433.     short y,m;
  434.  
  435.     m=MatrixLevel[CurrentWid];
  436.  
  437.     rotate_position(vert,rvert);
  438.     for(y=0;y<3;y++)
  439.         rvert[y]+=Translation[CurrentWid][m][y];
  440.     }
  441.  
  442.  
  443. /******************************************************************************
  444. void    rotate_position(float vert[3],float rvert[3])
  445.  
  446.     premultiplies vector to rotational matrix transform
  447. ******************************************************************************/
  448. /*PROTOTYPE*/
  449. void rotate_position(float vert[3],float rvert[3])
  450.     {
  451.     short x,y,d,m;
  452.  
  453.     d=Dimensions[CurrentWid];
  454.     m=MatrixLevel[CurrentWid];
  455.  
  456.     for(x=0;x<d;x++)
  457.         {
  458.         rvert[x]=0.0;
  459.         for(y=0;y<d;y++)
  460.             rvert[x]+=vert[y]*Rotate[CurrentWid][m][y][x];
  461.         }
  462.     }
  463.  
  464.  
  465. /******************************************************************************
  466. void    translate(float fx,float fy,float fz)
  467.  
  468. ******************************************************************************/
  469. /*PROTOTYPE*/
  470. void translate(float fx,float fy,float fz)
  471.     {
  472.     float vert[3],rvert[3];
  473.     short y,m;
  474.  
  475.     m=MatrixLevel[CurrentWid];
  476.  
  477.     vert[0]=fx;
  478.     vert[1]=fy;
  479.     vert[2]=fz;
  480.  
  481.     rotate_position(vert,rvert);
  482.  
  483.     for(y=0;y<3;y++)
  484.         Translation[CurrentWid][m][y]+=rvert[y];
  485.     }
  486.  
  487.  
  488. /******************************************************************************
  489. void    rot(float angle,long axis)
  490.  
  491.     angle in degrees
  492.  
  493.     rotates current matrix transform about an axis
  494. ******************************************************************************/
  495. /*PROTOTYPE*/
  496. void rot(float angle,long axis)
  497.     {
  498.     short x;
  499.     short m;
  500.     short i,j;
  501.     short angle1,angle2;
  502.  
  503.     float b,c;
  504.     float sina,cosa;
  505.  
  506.     m=MatrixLevel[CurrentWid];
  507.  
  508.     switch(axis)
  509.         {
  510.         case 'x':
  511.             Dimensions[CurrentWid]=3;
  512.             i=1;
  513.             j=2;
  514.             break;
  515.         case 'y':
  516.             Dimensions[CurrentWid]=3;
  517.             i=2;
  518.             j=0;
  519.             break;
  520.         case 'z':
  521.             i=0;
  522.             j=1;
  523.             break;
  524.         default:
  525.             return;
  526.         }
  527.  
  528. #if SINE_TABLE
  529.  
  530.     if(angle<0.0)
  531.         {
  532.         angle1=(short)(-angle)*10%3600;
  533.         sina= -Sine[angle1];
  534.         }
  535.     else
  536.         {
  537.         angle1=(short)(angle)*10%3600;
  538.         sina=Sine[angle1];
  539.         }
  540.  
  541.     angle2=(abs((short)angle)*10+900)%3600;
  542.     cosa=Sine[angle2];
  543.  
  544. #else
  545.  
  546.     angle*=DEG;
  547.  
  548.     sina=sin(angle);
  549.     cosa=cos(angle);
  550.  
  551. #endif
  552.  
  553.     for(x=0;x<3;x++)
  554.         {
  555.         b=Rotate[CurrentWid][m][i][x];
  556.         c=Rotate[CurrentWid][m][j][x];
  557.         Rotate[CurrentWid][m][i][x]=  b*cosa+c*sina;
  558.         Rotate[CurrentWid][m][j][x]= -b*sina+c*cosa;
  559.         }
  560.     }
  561.  
  562.  
  563. /******************************************************************************
  564. void    scale(float sx,float sy,float sz)
  565.  
  566. ******************************************************************************/
  567. /*PROTOTYPE*/
  568. void scale(float sx,float sy,float sz)
  569.     {
  570.     short x,m;
  571.  
  572.     m=MatrixLevel[CurrentWid];
  573.  
  574.     for(x=0;x<3;x++)
  575.         {
  576.         Rotate[CurrentWid][m][0][x]*=sx;
  577.         Rotate[CurrentWid][m][1][x]*=sy;
  578.         Rotate[CurrentWid][m][2][x]*=sz;
  579.         }
  580.     }
  581. @
  582.  
  583.  
  584. 1.2.1.1
  585. log
  586. @Added RCS Header
  587. @
  588. text
  589. @a0 16
  590.  
  591. /******************************************************************************
  592.  
  593. $Id: matrix.c,v 1.2.1.1 2002/03/26 22:04:15 jason Exp jason $
  594.  
  595. $Log: matrix.c,v $
  596.  * Revision 1.2.1.1  2002/03/26  22:04:15  jason
  597.  * Added RCS Header
  598.  *
  599.  * Revision 1.2.1.1  2002/03/26  22:00:51  jason
  600.  * RCS/agl.h,v
  601.  *
  602.  
  603. ******************************************************************************/
  604.  
  605.  
  606. @
  607.  
  608.  
  609. 1.2.1.2
  610. log
  611. @acceleration matrix operations: no more 4D arrays
  612. needs cleaning and further optimizations
  613. @
  614. text
  615. @d4 1
  616. a4 1
  617. $Id: matrix.c,v 1.2.1.1 1994/03/29 05:41:32 jason Exp jason $
  618. d7 1
  619. a7 1
  620.  * Revision 1.2.1.1  1994/03/29  05:41:32  jason
  621. d9 4
  622. a22 3
  623. #define    MATRIX_DEBUG    FALSE
  624. #define    VERTEX_DEBUG    FALSE
  625.  
  626. a32 6
  627. /* MACRO'S */
  628. #define PROJECTION(Y,X) ProjectionPointer[Y*4+X]
  629. #define TRANSLATION(Y) TranslatePointer[Y*4]
  630. #define ROTATION(Y,X) RotatePointer[Y*4+X]
  631.  
  632.  
  633. a33 1
  634.  
  635. d35 2
  636. a36 2
  637. float Transformation[MAX_WINDOWS][MATRIXSTACKDEPTH][4][4];
  638.  
  639. a38 2
  640. float *RotatePointer,*TranslatePointer,*ProjectionPointer;
  641.  
  642. a49 4
  643. #if MATRIX_DEBUG
  644.     printf("init_matrices()\n");
  645. #endif
  646.  
  647. d58 5
  648. a62 2
  649.         for(x=0;x<4;x++)
  650.             for(y=0;y<4;y++)
  651. d64 1
  652. a64 1
  653.                     Transformation[wid][0][y][x]=1.0;
  654. d66 2
  655. a67 1
  656.                     Transformation[wid][0][y][x]=0.0;
  657. a72 19
  658. void    reset_matrix_pointers(void)
  659.  
  660.     call from winset() to reset pointers to transform structures
  661.  
  662. ******************************************************************************/
  663. /*PROTOTYPE*/
  664. void reset_matrix_pointers(void)
  665.     {
  666.     short m;
  667.  
  668.     m=MatrixLevel[CurrentWid];
  669.  
  670.     RotatePointer= &(Transformation[CurrentWid][m][0][0]);
  671.     TranslatePointer= &(Transformation[CurrentWid][m][0][3]);
  672.     ProjectionPointer= &(Projection[CurrentWid][0][0]);
  673.     }
  674.  
  675.  
  676. /******************************************************************************
  677. d79 1
  678. a79 5
  679.     short x,y,m,n;
  680.  
  681. #if MATRIX_DEBUG
  682.     printf("pushmatrix() -> %d\n",MatrixLevel[CurrentWid]+1);
  683. #endif
  684. d89 2
  685. a90 1
  686.         memcpy(RotatePointer+16,RotatePointer,48);
  687. a100 3
  688.         /* move up pointers */
  689.         RotatePointer+=16;
  690.         TranslatePointer+=16;
  691. a111 4
  692. #if MATRIX_DEBUG
  693.     printf("popmatrix() -> %d\n",MatrixLevel[CurrentWid]-1);
  694. #endif
  695.  
  696. a114 1
  697.         {
  698. a116 5
  699.         /* move up pointers */
  700.         RotatePointer-=16;
  701.         TranslatePointer-=16;
  702.         }
  703.  
  704. d144 1
  705. a144 1
  706.             sum+=PROJECTION(y,m)*before[m];
  707. d150 1
  708. a150 1
  709.         out[y]=PROJECTION(3,2)*mid[y]/mid[3];
  710. d157 2
  711. a158 2
  712.         out[0]=PROJECTION(0,0)*in[0]/in[2];
  713.         out[1]=PROJECTION(1,1)*in[1]/in[2];
  714. d162 2
  715. a163 2
  716.         out[0]=PROJECTION(0,0)*in[0]+PROJECTION(3,0);
  717.         out[1]=PROJECTION(1,1)*in[1]+PROJECTION(3,1);
  718. a181 4
  719. #if MATRIX_DEBUG
  720.     printf("perspective()\n");
  721. #endif
  722.  
  723. d201 1
  724. a201 1
  725.                                             Projection[CurrentWid][0][0],Projection[CurrentWid][1][1]);
  726. a227 4
  727. #if MATRIX_DEBUG
  728.     printf("ortho2()\n");
  729. #endif
  730.  
  731. a366 1
  732.     short x,y;
  733. d375 7
  734. a381 43
  735. #if VERTEX_DEBUG
  736.     if(CurrentWid==1)
  737.         {
  738.         for(y=0;y<4;y++)
  739.             {
  740.             for(x=0;x<4;x++)
  741.                 printf("%5.2f ",Projection[CurrentWid][y][x]);
  742.  
  743.             printf(" ");
  744.  
  745.             for(x=0;x<4;x++)
  746.                 printf("%5.2f ",PROJECTION(y,x));
  747.  
  748.             printf(" ");
  749.  
  750.             for(x=0;x<4;x++)
  751.                 printf("%4.1f ",Transformation[CurrentWid][MatrixLevel[CurrentWid]][y][x]);
  752.  
  753.             printf(" ");
  754.  
  755.             if(y<3)
  756.                 {
  757.                 for(x=0;x<3;x++)
  758.                     printf("%4.1f ",ROTATION(y,x));
  759.  
  760.                 printf("%4.1f\n",TRANSLATION(y));
  761.                 }
  762.  
  763.             printf("\n");
  764.             }
  765.  
  766.         printf("%d %d  %d %d  %d\n",    &Projection[CurrentWid][0][0],
  767.                                     ProjectionPointer,
  768.                                     &Transformation[CurrentWid][MatrixLevel[CurrentWid]][0][0],
  769.                                     RotatePointer,
  770.                                     TranslatePointer);
  771.         printf("W%d M%d ",CurrentWid,MatrixLevel[CurrentWid]);
  772.         printf("%5.3f %5.3f %5.3f -> ",vert[0],vert[1],vert[2]);
  773.         printf("%5.3f %5.3f %5.3f -> ",rvert[0],rvert[1],rvert[2]);
  774.         printf("%5.3f %5.3f -> ",pvert[0],pvert[1]);
  775.         printf("%4d %4d\n",svert[0],svert[1]);
  776.         }
  777. #endif
  778. a395 3
  779.     rotate_position(vert,rvert);
  780.  
  781. #if FALSE
  782. d398 1
  783. a398 1
  784.     /* the original (keep for reference) */
  785. a400 5
  786. #endif
  787.  
  788.     rvert[0]+=TRANSLATION(0);
  789.     rvert[1]+=TRANSLATION(1);
  790.     rvert[2]+=TRANSLATION(2);
  791. a414 2
  792.  
  793. #if FALSE
  794. a416 1
  795.     /* the original (keep for reference) */
  796. a422 25
  797. #endif
  798.  
  799.     /* unrolled and optimised */
  800.     if(d==3)
  801.         {
  802.         rvert[0]=    vert[0]*ROTATION(0,0)
  803.                 +    vert[1]*ROTATION(1,0)
  804.                 +    vert[2]*ROTATION(2,0);
  805.  
  806.         rvert[1]=    vert[0]*ROTATION(0,1)
  807.                 +    vert[1]*ROTATION(1,1)
  808.                 +    vert[2]*ROTATION(2,1);
  809.  
  810.         rvert[2]=    vert[0]*ROTATION(0,2)
  811.                 +    vert[1]*ROTATION(1,2)
  812.                 +    vert[2]*ROTATION(2,2);
  813.         }
  814.     else
  815.         {
  816.         rvert[0]=    vert[0]*ROTATION(0,0)
  817.                 +    vert[1]*ROTATION(1,0);
  818.  
  819.         rvert[1]=    vert[0]*ROTATION(0,1)
  820.                 +    vert[1]*ROTATION(1,1);
  821.         }
  822. d436 1
  823. a436 3
  824. #if MATRIX_DEBUG
  825.     printf("translate(%.2f %.2f %.2f)\n",fx,fy,fz);
  826. #endif
  827. a443 4
  828. #if FALSE
  829.     m=MatrixLevel[CurrentWid];
  830.  
  831.     /* the original (keep for reference) */
  832. a445 6
  833. #endif
  834.  
  835.     /* unrolled and optimised */
  836.     TRANSLATION(0)+=rvert[0];
  837.     TRANSLATION(1)+=rvert[1];
  838.     TRANSLATION(2)+=rvert[2];
  839. d467 1
  840. a467 3
  841. #if MATRIX_DEBUG
  842.     printf("rot(%.2f,%c)\n",angle,axis);
  843. #endif
  844. a513 4
  845. #if FALSE
  846.     m=MatrixLevel[CurrentWid];
  847.  
  848.     /* the original (keep for reference) */
  849. a520 17
  850. #endif
  851.  
  852.     /* unrolled and optimised */
  853.     b=ROTATION(i,0);
  854.     c=ROTATION(j,0);
  855.     ROTATION(i,0)=  b*cosa+c*sina;
  856.     ROTATION(j,0)= -b*sina+c*cosa;
  857.  
  858.     b=ROTATION(i,1);
  859.     c=ROTATION(j,1);
  860.     ROTATION(i,1)=  b*cosa+c*sina;
  861.     ROTATION(j,1)= -b*sina+c*cosa;
  862.  
  863.     b=ROTATION(i,2);
  864.     c=ROTATION(j,2);
  865.     ROTATION(i,2)=  b*cosa+c*sina;
  866.     ROTATION(j,2)= -b*sina+c*cosa;
  867. a532 5
  868. #if MATRIX_DEBUG
  869.     printf("scale(%.2f %.2f %.2f )\n",sx,sy,sz);
  870. #endif
  871.  
  872. #if FALSE
  873. a534 1
  874.     /* the original (keep for reference) */
  875. a540 14
  876. #endif
  877.  
  878.     /* unrolled and optimised */
  879.     ROTATION(0,0)*=sx;
  880.     ROTATION(1,0)*=sy;
  881.     ROTATION(2,0)*=sz;
  882.  
  883.     ROTATION(0,1)*=sx;
  884.     ROTATION(1,1)*=sy;
  885.     ROTATION(2,1)*=sz;
  886.  
  887.     ROTATION(0,2)*=sx;
  888.     ROTATION(1,2)*=sy;
  889.     ROTATION(2,2)*=sz;
  890. @
  891.  
  892.  
  893. 1.2.1.3
  894. log
  895. @Separate rotation for X, Y, and Z axes
  896. @
  897. text
  898. @d4 1
  899. a4 1
  900. $Id: matrix.c,v 1.2.1.2 1994/04/02 03:33:11 jason Exp jason $
  901. a6 4
  902.  * Revision 1.2.1.2  1994/04/02  03:33:11  jason
  903.  * acceleration matrix operations: no more 4D arrays
  904.  * needs cleaning and further optimizations
  905.  *
  906. a23 1
  907. #define    FAST_ROT        TRUE
  908. d33 3
  909. a35 3
  910. #define PROJECTION(Y,X) ProjectionPointer[(Y<<2)+X]
  911. #define TRANSLATION(Y) TranslatePointer[(Y<<2)]
  912. #define ROTATION(Y,X) RotatePointer[(Y<<2)+X]
  913. d106 1
  914. a106 2
  915. /*     short x,y; */
  916.     short m;
  917. d306 1
  918. a307 1
  919.     float fvert[3];
  920. d389 1
  921. a390 1
  922.     float fvert[3];
  923. d416 1
  924. d418 1
  925. a418 1
  926.     float rvert[3],pvert[3];
  927. a424 1
  928.  
  929. d482 1
  930. a482 1
  931. /*     short y,m; */
  932. d508 1
  933. a508 2
  934.     short d;
  935. /*     short x,y,m; */
  936. d558 1
  937. a558 1
  938. /*     short y,m; */
  939. d595 2
  940. d607 20
  941. d631 1
  942. a631 1
  943.         angle1=(short)(-angle*10.0)%3600;
  944. d636 1
  945. a636 1
  946.         angle1=(short)(angle*10.0)%3600;
  947. d640 1
  948. a640 1
  949.     angle2=(abs((short)(angle*10.0))+900)%3600;
  950. a651 74
  951.     switch(axis)
  952.         {
  953.         case 'x':
  954.             Dimensions[CurrentWid]=3;
  955. #if FAST_ROT
  956.             b=ROTATION(1,0);
  957.             c=ROTATION(2,0);
  958.             ROTATION(1,0)=  b*cosa+c*sina;
  959.             ROTATION(2,0)= -b*sina+c*cosa;
  960.  
  961.             b=ROTATION(1,1);
  962.             c=ROTATION(2,1);
  963.             ROTATION(1,1)=  b*cosa+c*sina;
  964.             ROTATION(2,1)= -b*sina+c*cosa;
  965.  
  966.             b=ROTATION(1,2);
  967.             c=ROTATION(2,2);
  968.             ROTATION(1,2)=  b*cosa+c*sina;
  969.             ROTATION(2,2)= -b*sina+c*cosa;
  970. #else
  971.             i=1;
  972.             j=2;
  973. #endif
  974.             break;
  975.  
  976.         case 'y':
  977.             Dimensions[CurrentWid]=3;
  978. #if FAST_ROT
  979.             b=ROTATION(2,0);
  980.             c=ROTATION(0,0);
  981.             ROTATION(2,0)=  b*cosa+c*sina;
  982.             ROTATION(0,0)= -b*sina+c*cosa;
  983.  
  984.             b=ROTATION(2,1);
  985.             c=ROTATION(0,1);
  986.             ROTATION(2,1)=  b*cosa+c*sina;
  987.             ROTATION(0,1)= -b*sina+c*cosa;
  988.  
  989.             b=ROTATION(2,2);
  990.             c=ROTATION(0,2);
  991.             ROTATION(2,2)=  b*cosa+c*sina;
  992.             ROTATION(0,2)= -b*sina+c*cosa;
  993. #else
  994.             i=2;
  995.             j=0;
  996. #endif
  997.             break;
  998.  
  999.         case 'z':
  1000. #if FAST_ROT
  1001.             b=ROTATION(0,0);
  1002.             c=ROTATION(1,0);
  1003.             ROTATION(0,0)=  b*cosa+c*sina;
  1004.             ROTATION(1,0)= -b*sina+c*cosa;
  1005.  
  1006.             b=ROTATION(0,1);
  1007.             c=ROTATION(1,1);
  1008.             ROTATION(0,1)=  b*cosa+c*sina;
  1009.             ROTATION(1,1)= -b*sina+c*cosa;
  1010.  
  1011.             b=ROTATION(0,2);
  1012.             c=ROTATION(1,2);
  1013.             ROTATION(0,2)=  b*cosa+c*sina;
  1014.             ROTATION(1,2)= -b*sina+c*cosa;
  1015. #else
  1016.             i=0;
  1017.             j=1;
  1018. #endif
  1019.             break;
  1020.  
  1021.         default:
  1022.             return;
  1023.         }
  1024.  
  1025. d665 1
  1026. a665 3
  1027. #if !FAST_ROT
  1028.  
  1029.     /* unrolled and optimised (general case) */
  1030. a679 2
  1031.  
  1032. #endif
  1033. d690 1
  1034. a690 1
  1035. /*     short x,m; */
  1036. @
  1037.  
  1038.  
  1039. 1.2.1.4
  1040. log
  1041. @added fixed-point test
  1042. @
  1043. text
  1044. @d4 1
  1045. a4 1
  1046. $Id: matrix.c,v 1.2.1.3 1994/04/06 02:39:10 jason Exp jason $
  1047. a6 3
  1048.  * Revision 1.2.1.3  1994/04/06  02:39:10  jason
  1049.  * Separate rotation for X, Y, and Z axes
  1050.  *
  1051. a16 1
  1052. #ifndef NOT_EXTERN
  1053. a17 1
  1054. #endif
  1055. a29 1
  1056. #define FIXED_POINT        FALSE
  1057. d38 3
  1058. a40 31
  1059. #define PROJECTION(Y,X)    ProjectionPointer[(Y<<2)+X]
  1060. #define TRANSLATION(Y)    TranslatePointer[(Y<<2)]
  1061. #define ROTATION(Y,X)    RotatePointer[(Y<<2)+X]
  1062.  
  1063. #if FIXED_POINT
  1064.  
  1065.     #define FIXING_POINT    10000
  1066.  
  1067.     #define FIXVALUE(x)        (x*FIXING_POINT)
  1068.     #define FIXBACK(x)        (x/(float)FIXING_POINT)
  1069.     #define FIXMULT(x,y)    (x*y/FIXING_POINT)
  1070.     #define FIXDIVIDE(x,y)    (FIXING_POINT*x/y)
  1071.  
  1072.     #define FIXTYPE            long long
  1073.  
  1074. #else
  1075.  
  1076.     #define FIXVALUE(x)        x
  1077.     #define FIXBACK(x)        x
  1078.     #define FIXMULT(x,y)    (x*y)
  1079.     #define FIXDIVIDE(x,y)    (x/y)
  1080.  
  1081.     #define FIXTYPE            float
  1082.  
  1083. #endif
  1084.  
  1085.  
  1086. /* isolated prototypes */
  1087. void rotate_translate_position(FIXTYPE vert[3],FIXTYPE rvert[3]);
  1088. void rotate_position(FIXTYPE vert[3],FIXTYPE rvert[3]);
  1089. void project_vertex(FIXTYPE in[3],FIXTYPE out[3]);
  1090. d43 1
  1091. a43 3
  1092. short MatrixLevel[MAX_WINDOWS];
  1093. short ProjectionType[MAX_WINDOWS];
  1094. short OrthoAligned[MAX_WINDOWS];
  1095. d45 2
  1096. a46 2
  1097. FIXTYPE Projection[MAX_WINDOWS][4][4];
  1098. FIXTYPE Transformation[MAX_WINDOWS][MATRIXSTACKDEPTH][4][4];
  1099. d48 1
  1100. a48 1
  1101. FIXTYPE Sine[3600];
  1102. d50 1
  1103. a50 1
  1104. FIXTYPE *RotatePointer,*TranslatePointer,*ProjectionPointer;
  1105. d69 1
  1106. a69 1
  1107.         Sine[x]=FIXVALUE(sin(x/10.0*DEG));
  1108. d78 1
  1109. a78 1
  1110.                     Transformation[wid][0][y][x]=FIXVALUE(1.0);
  1111. d80 1
  1112. a80 1
  1113.                     Transformation[wid][0][y][x]=FIXVALUE(0.0);
  1114. d126 1
  1115. a126 1
  1116.         memcpy(RotatePointer+16,RotatePointer,12*sizeof(FIXTYPE));
  1117. d172 1
  1118. a172 1
  1119. void    project_vertex(FIXTYPE in[3],FIXTYPE out[3])
  1120. d176 2
  1121. a177 2
  1122. /*NO PROTOTYPE*/
  1123. void project_vertex(FIXTYPE in[3],FIXTYPE out[3])
  1124. a180 2
  1125.     ERROR: NOT_CURRENT
  1126.  
  1127. a205 2
  1128.         /* mult and divide cancel fixed point effect */
  1129.  
  1130. d211 2
  1131. a212 2
  1132.         out[0]=FIXMULT(PROJECTION(0,0),in[0])+PROJECTION(3,0);
  1133.         out[1]=FIXMULT(PROJECTION(1,1),in[1])+PROJECTION(3,1);
  1134. a235 1
  1135.     OrthoAligned[CurrentWid]=FALSE;
  1136. d246 5
  1137. a250 5
  1138.     Projection[CurrentWid][0][0]=FIXVALUE(cot/aspect);
  1139.     Projection[CurrentWid][1][1]=FIXVALUE(cot);
  1140.     Projection[CurrentWid][2][2]=FIXVALUE(     -(far+near)/(far-near));
  1141.     Projection[CurrentWid][2][3]=FIXVALUE( -1.0);
  1142.     Projection[CurrentWid][3][2]=FIXVALUE( -(2.0*far*near)/(far-near));
  1143. d269 2
  1144. a270 2
  1145.     Projection[CurrentWid][2][2]=FIXVALUE( -2.0/(far-near));
  1146.     Projection[CurrentWid][3][2]=FIXVALUE( -(far+near)/(far-near));
  1147. d289 6
  1148. a294 6
  1149.     Projection[CurrentWid][0][0]=FIXVALUE(2.0/(right-left));
  1150.     Projection[CurrentWid][1][1]=FIXVALUE(2.0/(top-bottom));
  1151.     Projection[CurrentWid][2][2]=FIXVALUE( -1.0);
  1152.     Projection[CurrentWid][3][0]=FIXVALUE( -(right+left)/(right-left));
  1153.     Projection[CurrentWid][3][1]=FIXVALUE( -(top+bottom)/(top-bottom));
  1154.     Projection[CurrentWid][3][3]=FIXVALUE(1.0);
  1155. d296 1
  1156. a296 6
  1157.     ProjectionType[CurrentWid]=ORTHO;
  1158.  
  1159.     OrthoAligned[CurrentWid]= ( left==(-0.5) && right==(CurrentWidth-0.5) &&
  1160.                                                          bottom==(-0.5) && top==(CurrentHeight-0.5) );
  1161.  
  1162.     if(OrthoAligned[CurrentWid] && viewport_aligned())
  1163. a299 1
  1164.     }
  1165. d301 1
  1166. a301 31
  1167.  
  1168. /******************************************************************************
  1169. void    viewport(Screencoord left,Screencoord right,
  1170.                                         Screencoord bottom,Screencoord top)
  1171. ******************************************************************************/
  1172. /*PROTOTYPE*/
  1173. void viewport(Screencoord left,Screencoord right,Screencoord bottom,Screencoord top)
  1174.     {
  1175.     ViewPort[CurrentWid][0]=left;
  1176.     ViewPort[CurrentWid][1]=right-left+1;
  1177.     ViewPort[CurrentWid][2]=bottom;
  1178.     ViewPort[CurrentWid][3]=top-bottom+1;
  1179.  
  1180.     scrmask(left,right,bottom,top);
  1181.  
  1182.     if(OrthoAligned[CurrentWid] && viewport_aligned())
  1183.         OneToOne[CurrentWid]=TRUE;
  1184.     else
  1185.         OneToOne[CurrentWid]=FALSE;
  1186.     }
  1187.  
  1188.  
  1189. /******************************************************************************
  1190. long    viewport_aligned(void)
  1191.  
  1192. ******************************************************************************/
  1193. /*PROTOTYPE*/
  1194. long viewport_aligned(void)
  1195.     {
  1196.     return (ViewPort[CurrentWid][0]==0 && ViewPort[CurrentWid][1]==CurrentWidth &&
  1197.                                     ViewPort[CurrentWid][2]==0 && ViewPort[CurrentWid][3]==CurrentHeight );
  1198. d423 1
  1199. a423 10
  1200.     FIXTYPE fvert[3],rvert[3],pvert[3];
  1201.  
  1202. #if FIXED_POINT
  1203.  
  1204.     fvert[0]=FIXVALUE(vert[0]);
  1205.     fvert[1]=FIXVALUE(vert[1]);
  1206.     fvert[2]=FIXVALUE(vert[2]);
  1207.     rotate_translate_position(fvert,rvert);
  1208.  
  1209. #else
  1210. a425 3
  1211.  
  1212. #endif
  1213.  
  1214. d428 2
  1215. a429 7
  1216. /*
  1217.     svert[0]=CurrentWidth  * FIXBACK(FIXDIVIDE((pvert[0]+1.0),2.0)) + 0.5;
  1218.     svert[1]=CurrentHeight * FIXBACK(FIXDIVIDE((pvert[1]+1.0),2.0)) + 0.5;
  1219. */
  1220.  
  1221.     svert[0]=ViewPort[CurrentWid][0]+ ViewPort[CurrentWid][1] * FIXBACK(FIXDIVIDE((pvert[0]+1.0),2.0));
  1222.     svert[1]=ViewPort[CurrentWid][2]+ ViewPort[CurrentWid][3] * FIXBACK(FIXDIVIDE((pvert[1]+1.0),2.0));
  1223. d480 1
  1224. a480 1
  1225. void    rotate_translate_position(FIXTYPE vert[3],FIXTYPE rvert[3])
  1226. d485 2
  1227. a486 2
  1228. /*NO PROTOTYPE*/
  1229. void rotate_translate_position(FIXTYPE vert[3],FIXTYPE rvert[3])
  1230. d507 1
  1231. a507 1
  1232. void    rotate_position(FIXTYPE vert[3],FIXTYPE rvert[3])
  1233. d511 2
  1234. a512 2
  1235. /*NO PROTOTYPE*/
  1236. void rotate_position(FIXTYPE vert[3],FIXTYPE rvert[3])
  1237. d534 11
  1238. a544 11
  1239.         rvert[0]=    FIXMULT(vert[0],ROTATION(0,0))
  1240.                 +    FIXMULT(vert[1],ROTATION(1,0))
  1241.                 +    FIXMULT(vert[2],ROTATION(2,0));
  1242.  
  1243.         rvert[1]=    FIXMULT(vert[0],ROTATION(0,1))
  1244.                 +    FIXMULT(vert[1],ROTATION(1,1))
  1245.                 +    FIXMULT(vert[2],ROTATION(2,1));
  1246.  
  1247.         rvert[2]=    FIXMULT(vert[0],ROTATION(0,2))
  1248.                 +    FIXMULT(vert[1],ROTATION(1,2))
  1249.                 +    FIXMULT(vert[2],ROTATION(2,2));
  1250. d548 2
  1251. a549 2
  1252.         rvert[0]=    FIXMULT(vert[0],ROTATION(0,0))
  1253.                 +    FIXMULT(vert[1],ROTATION(1,0));
  1254. d551 2
  1255. a552 2
  1256.         rvert[1]=    FIXMULT(vert[0],ROTATION(0,1))
  1257.                 +    FIXMULT(vert[1],ROTATION(1,1));
  1258. d564 1
  1259. a564 1
  1260.     FIXTYPE vert[3],rvert[3];
  1261. a566 2
  1262.     OneToOne[CurrentWid]=FALSE;
  1263.  
  1264. d571 3
  1265. a573 3
  1266.     vert[0]=FIXVALUE(fx);
  1267.     vert[1]=FIXVALUE(fy);
  1268.     vert[2]=FIXVALUE(fz);
  1269. d605 2
  1270. a606 4
  1271.     FIXTYPE b,c;
  1272.     FIXTYPE sina,cosa;
  1273.  
  1274.     OneToOne[CurrentWid]=FALSE;
  1275. d616 1
  1276. a616 1
  1277.         angle1=(long)(-angle*10.0)%3600;
  1278. d621 1
  1279. a621 1
  1280.         angle1=(long)(angle*10.0)%3600;
  1281. d625 1
  1282. a625 1
  1283.     angle2=(abs((long)(angle*10.0))+900)%3600;
  1284. d644 2
  1285. a645 2
  1286.             ROTATION(1,0)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1287.             ROTATION(2,0)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1288. d649 2
  1289. a650 2
  1290.             ROTATION(1,1)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1291.             ROTATION(2,1)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1292. d654 2
  1293. a655 2
  1294.             ROTATION(1,2)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1295.             ROTATION(2,2)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1296. d667 2
  1297. a668 2
  1298.             ROTATION(2,0)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1299.             ROTATION(0,0)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1300. d672 2
  1301. a673 2
  1302.             ROTATION(2,1)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1303.             ROTATION(0,1)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1304. d677 2
  1305. a678 2
  1306.             ROTATION(2,2)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1307.             ROTATION(0,2)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1308. d689 2
  1309. a690 2
  1310.             ROTATION(0,0)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1311.             ROTATION(1,0)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1312. d694 2
  1313. a695 2
  1314.             ROTATION(0,1)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1315.             ROTATION(1,1)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1316. d699 2
  1317. a700 2
  1318.             ROTATION(0,2)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1319.             ROTATION(1,2)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1320. d729 2
  1321. a730 2
  1322.     ROTATION(i,0)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1323.     ROTATION(j,0)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1324. d734 2
  1325. a735 2
  1326.     ROTATION(i,1)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1327.     ROTATION(j,1)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1328. d739 2
  1329. a740 2
  1330.     ROTATION(i,2)= FIXMULT( b,cosa) + FIXMULT(c,sina);
  1331.     ROTATION(j,2)= FIXMULT(-b,sina) + FIXMULT(c,cosa);
  1332. a754 36
  1333. #if FIXED_POINT
  1334.     FIXTYPE sx2,sy2,sz2;
  1335.  
  1336.     sx2=FIXVALUE(sx);
  1337.     sy2=FIXVALUE(sy);
  1338.     sz2=FIXVALUE(sz);
  1339.  
  1340.     /* unrolled and optimised */
  1341.     ROTATION(0,0)*=sx2/FIXING_POINT;
  1342.     ROTATION(1,0)*=sy2/FIXING_POINT;
  1343.     ROTATION(2,0)*=sz2/FIXING_POINT;
  1344.  
  1345.     ROTATION(0,1)*=sx2/FIXING_POINT;
  1346.     ROTATION(1,1)*=sy2/FIXING_POINT;
  1347.     ROTATION(2,1)*=sz2/FIXING_POINT;
  1348.  
  1349.     ROTATION(0,2)*=sx2/FIXING_POINT;
  1350.     ROTATION(1,2)*=sy2/FIXING_POINT;
  1351.     ROTATION(2,2)*=sz2/FIXING_POINT;
  1352. #else
  1353.     /* unrolled and optimised */
  1354.     ROTATION(0,0)*=sx;
  1355.     ROTATION(1,0)*=sy;
  1356.     ROTATION(2,0)*=sz;
  1357.  
  1358.     ROTATION(0,1)*=sx;
  1359.     ROTATION(1,1)*=sy;
  1360.     ROTATION(2,1)*=sz;
  1361.  
  1362.     ROTATION(0,2)*=sx;
  1363.     ROTATION(1,2)*=sy;
  1364.     ROTATION(2,2)*=sz;
  1365. #endif
  1366.  
  1367.     OneToOne[CurrentWid]=FALSE;
  1368.  
  1369. d771 12
  1370. @
  1371.  
  1372.  
  1373. 1.2.1.5
  1374. log
  1375. @added matrix load and get
  1376. @
  1377. text
  1378. @d4 1
  1379. a4 1
  1380. $Id: matrix.c,v 1.2.1.4 1994/09/13 03:48:33 jason Exp jason $
  1381. a6 3
  1382.  * Revision 1.2.1.4  1994/09/13  03:48:33  jason
  1383.  * added fixed-point test
  1384.  *
  1385. d28 2
  1386. a29 2
  1387. #define    MATRIX_DEBUG        FALSE
  1388. #define    VERTEX_DEBUG        FALSE
  1389. d31 5
  1390. a35 5
  1391. #define    CLEAR_PROJECTION    TRUE
  1392. #define    FAST_PUSH            TRUE
  1393. #define    FAST_ROT            TRUE
  1394. #define SINE_TABLE            TRUE
  1395. #define FIXED_POINT            FALSE
  1396. d39 2
  1397. a40 3
  1398. #define PROJ_ORTHO            0
  1399. #define PROJ_PERSPECTIVE    1
  1400. #define PROJ_CUSTOM            2
  1401. d45 1
  1402. a45 1
  1403. #define TRANSLATION(X)    TranslatePointer[X]
  1404. a76 8
  1405. static Matrix IdentityMatrix=
  1406.     {
  1407.     1.0, 0.0, 0.0, 0.0,
  1408.     0.0, 1.0, 0.0, 0.0,
  1409.     0.0, 0.0, 1.0, 0.0,
  1410.     0.0, 0.0, 0.0, 1.0,
  1411.     };
  1412.  
  1413. a79 1
  1414. short MatrixMode=MSINGLE;
  1415. d135 1
  1416. a135 1
  1417.     TranslatePointer= &(Transformation[CurrentWid][m][3][0]);
  1418. d162 1
  1419. a162 1
  1420.         memcpy(RotatePointer+16,RotatePointer,16*sizeof(FIXTYPE));
  1421. d208 1
  1422. a208 7
  1423. void    mmode(short mode)
  1424.  
  1425.     set matrix mode:
  1426.         MSINGLE
  1427.         MVIEWING
  1428.         MPROJECTION
  1429.         MTEXTURE
  1430. d210 1
  1431. d212 2
  1432. a213 2
  1433. /*PROTOTYPE*/
  1434. void mmode(short mode)
  1435. d215 1
  1436. a215 15
  1437.     if(mode!=MSINGLE && mode!=MVIEWING && mode!=MPROJECTION && mode!=MTEXTURE )
  1438.         {
  1439.         GL_error("(INTERNAL) getmatrix: illegal MatrixMode");
  1440.         }
  1441.     else
  1442.         {
  1443.         MatrixMode=mode;
  1444.  
  1445.         if(mode==MSINGLE)
  1446.             GL_error("MSINGLE obsolete: using MVIEWING");
  1447.         
  1448.         if(mode==MTEXTURE)
  1449.             GL_error("MTEXTURE not supported");
  1450.         }
  1451.     }
  1452. d217 1
  1453. d219 2
  1454. a220 2
  1455. /******************************************************************************
  1456. long    getmmode(void)
  1457. d222 4
  1458. a225 6
  1459. ******************************************************************************/
  1460. /*PROTOTYPE*/
  1461. long getmmode(void)
  1462.     {
  1463.     return MatrixMode;
  1464.     }
  1465. d227 1
  1466. a227 11
  1467.  
  1468. /******************************************************************************
  1469. void    getmatrix(Matrix  m)
  1470.  
  1471.     give user the current transform
  1472.  
  1473. ******************************************************************************/
  1474. /*PROTOTYPE*/
  1475. void getmatrix(Matrix  m)
  1476.     {
  1477.     switch(MatrixMode)
  1478. d229 4
  1479. a232 16
  1480.         case MSINGLE:
  1481.         case MVIEWING:
  1482.             memcpy(m,RotatePointer,sizeof(Matrix));
  1483.             break;
  1484.  
  1485.         case MPROJECTION:
  1486.             memcpy(m,ProjectionPointer,sizeof(Matrix));
  1487.             break;
  1488.  
  1489.         case MTEXTURE:
  1490.             memset(m,0,sizeof(Matrix));
  1491.             break;
  1492.  
  1493.         default:
  1494.             GL_error("(INTERNAL) getmatrix: illegal MatrixMode");
  1495.             break;
  1496. a233 1
  1497.     }
  1498. d235 3
  1499. d239 1
  1500. a239 4
  1501. /******************************************************************************
  1502. void    loadmatrix(Matrix  m)
  1503.  
  1504.     use the users custom matrix
  1505. d241 2
  1506. a242 5
  1507. ******************************************************************************/
  1508. /*PROTOTYPE*/
  1509. void loadmatrix(Matrix  m)
  1510.     {
  1511.     switch(MatrixMode)
  1512. d244 1
  1513. a244 9
  1514.         case MSINGLE:
  1515.         case MVIEWING:
  1516.             memcpy(RotatePointer,m,sizeof(Matrix));
  1517.             break;
  1518.  
  1519.         case MPROJECTION:
  1520.             memcpy(ProjectionPointer,m,sizeof(Matrix));
  1521.             ProjectionType[CurrentWid]=PROJ_CUSTOM;
  1522.             break;
  1523. d246 2
  1524. a247 7
  1525.         case MTEXTURE:
  1526.             GL_error("loadmatrix: MTEXTURE matrix mode not supported -> can't load matrix");
  1527.             break;
  1528.  
  1529.         default:
  1530.             GL_error("(INTERNAL) loadmatrix: illegal MatrixMode");
  1531.             break;
  1532. d249 1
  1533. a249 62
  1534.  
  1535.     OneToOne[CurrentWid]=is_one_to_one(RotatePointer);
  1536.     }
  1537.  
  1538.  
  1539. /******************************************************************************
  1540. void    multmatrix(Matrix  m)
  1541.  
  1542.     pre-multiply current matrix by user's custom transform
  1543.  
  1544. ******************************************************************************/
  1545. /*PROTOTYPE*/
  1546. void multmatrix(Matrix  m)
  1547.     {
  1548.     Matrix temp;
  1549.  
  1550.     short x,y;
  1551.     short n;
  1552.  
  1553.     memcpy(temp,RotatePointer,sizeof(Matrix));
  1554.  
  1555.     for(y=0;y<4;y++)
  1556.         for(x=0;x<4;x++)
  1557.             {
  1558.             ROTATION(y,x)=0;
  1559.  
  1560.             for(n=0;n<4;n++)
  1561.                 ROTATION(y,x)+=m[y][n]*temp[n][x];
  1562.             }
  1563.  
  1564.     OneToOne[CurrentWid]=is_one_to_one(RotatePointer);
  1565.     }
  1566.  
  1567.  
  1568. /******************************************************************************
  1569. long    is_one_to_one(Matrix m)
  1570.  
  1571.     returns TRUE if given 4x4 matrix is an identity
  1572.  
  1573. ******************************************************************************/
  1574. /*PROTOTYPE*/
  1575. long is_one_to_one(Matrix m)
  1576.     {
  1577.     return OrthoAligned[CurrentWid] && viewport_aligned() &&
  1578.                                                 memcmp(RotatePointer,IdentityMatrix,sizeof(Matrix))==0;
  1579.     }
  1580.  
  1581.  
  1582. /******************************************************************************
  1583. void    project_vertex(FIXTYPE in[3],FIXTYPE out[3])
  1584.  
  1585.     applies perspective on transformed vertex
  1586. ******************************************************************************/
  1587. /*NO PROTOTYPE*/
  1588. void project_vertex(FIXTYPE in[3],FIXTYPE out[3])
  1589.     {
  1590. #if !FAST_PROJECTION
  1591.  
  1592.     short x,m;
  1593.     float sum,before[4],mid[4];
  1594.  
  1595.     switch(ProjectionType[CurrentWid])
  1596. d251 3
  1597. a253 2
  1598.         case PROJ_ORTHO:
  1599.             /* fast: compute only x and y for ortho projection */
  1600. d255 1
  1601. a255 58
  1602.             out[0]=FIXMULT(PROJECTION(0,0),in[0])+PROJECTION(3,0);
  1603.             out[1]=FIXMULT(PROJECTION(1,1),in[1])+PROJECTION(3,1);
  1604.             break;
  1605.  
  1606.         case PROJ_PERSPECTIVE:
  1607.             /* fast: compute only x and y for perspective projection */
  1608.  
  1609.             /* mult and divide cancel fixed point effect */
  1610.  
  1611.             out[0]= -PROJECTION(0,0)*in[0]/in[2];
  1612.             out[1]= -PROJECTION(1,1)*in[1]/in[2];
  1613.             break;
  1614.  
  1615.         case PROJ_CUSTOM:
  1616.             /* complete: general purpose, any transform matrix */
  1617.  
  1618.             for(x=0;x<3;x++)
  1619.                 before[x]=in[x];
  1620.             before[3]=1.0;
  1621.  
  1622.             for(x=0;x<4;x++)
  1623.                 {
  1624.                 sum=0.0;
  1625.                 for(m=0;m<4;m++)
  1626.                     sum+=PROJECTION(m,x)*before[m];
  1627.  
  1628.                 mid[x]=sum;
  1629.                 }
  1630.  
  1631.             /* divide out range factor */
  1632.             for(x=0;x<3;x++)
  1633.                 out[x]= -mid[x]/mid[3];
  1634.  
  1635. /*                 out[y]=PROJECTION(3,2)*mid[y]/mid[3]; */
  1636.  
  1637. /*
  1638.             for(m=0;m<4;m++)
  1639.                 {
  1640.                 for(x=0;x<4;x++)
  1641.                     printf("%8.2f ",PROJECTION(m,x));
  1642.  
  1643.                 printf("\n");
  1644.                 }
  1645.  
  1646.             printf("\nbefore\n");
  1647.             for(x=0;x<4;x++)
  1648.                 printf("%8.2f ",before[x]);
  1649.  
  1650.             printf("\nmid\n");
  1651.             for(x=0;x<4;x++)
  1652.                 printf("%8.2f ",mid[x]);
  1653.  
  1654.             printf("\nout\n");
  1655.             for(x=0;x<4;x++)
  1656.                 printf("%8.2f ",out[x]);
  1657. */
  1658.             break;
  1659.         }
  1660. d278 1
  1661. a278 1
  1662.     ProjectionType[CurrentWid]=PROJ_PERSPECTIVE;
  1663. d283 2
  1664. a284 2
  1665. #if CLEAR_PROJECTION
  1666.     memset(&Projection[CurrentWid][0][0],0,sizeof(Matrix));
  1667. d326 1
  1668. a326 1
  1669. #if CLEAR_PROJECTION
  1670. d337 1
  1671. a337 1
  1672.     ProjectionType[CurrentWid]=PROJ_ORTHO;
  1673. d342 4
  1674. a345 1
  1675.     OneToOne[CurrentWid]=is_one_to_one(RotatePointer);
  1676. d363 4
  1677. a366 1
  1678.     OneToOne[CurrentWid]=is_one_to_one(RotatePointer);
  1679. a646 2
  1680.  
  1681.         rvert[2]=    vert[2];
  1682. @
  1683.  
  1684.  
  1685. 1.2.1.6
  1686. log
  1687. @added copyright
  1688. @
  1689. text
  1690. @d1 1
  1691. d4 1
  1692. a4 4
  1693. Copyright © 1994 Jason Weber
  1694. All Rights Reserved
  1695.  
  1696. $Id: matrix.c,v 1.2.1.5 1994/11/18 07:49:22 jason Exp jason $
  1697. a6 3
  1698.  * Revision 1.2.1.5  1994/11/18  07:49:22  jason
  1699.  * added matrix load and get
  1700.  *
  1701. @
  1702.  
  1703.  
  1704.  
  1705.  
  1706.  
  1707.  
  1708.  
  1709.  
  1710.  
  1711.  
  1712.  
  1713.  
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719.  
  1720.  
  1721.  
  1722.  
  1723.  
  1724.  
  1725.  
  1726.  
  1727.  
  1728.  
  1729.  
  1730.  
  1731.  
  1732.  
  1733.  
  1734.  
  1735.  
  1736.  
  1737.  
  1738.  
  1739.  
  1740.  
  1741.  
  1742.  
  1743.  
  1744.  
  1745.  
  1746.  
  1747.  
  1748.  
  1749.  
  1750.  
  1751.  
  1752.  
  1753.  
  1754.  
  1755.  
  1756.  
  1757.  
  1758.  
  1759.  
  1760.  
  1761.  
  1762.  
  1763.  
  1764.  
  1765.  
  1766.  
  1767.  
  1768.  
  1769.  
  1770.  
  1771.  
  1772.  
  1773.  
  1774.  
  1775.  
  1776.  
  1777.  
  1778.  
  1779.  
  1780.  
  1781.  
  1782.  
  1783.  
  1784.